home *** CD-ROM | disk | FTP | other *** search
/ Aminet 30 / Aminet 30 (1999)(Schatztruhe)[!][Apr 1999].iso / Aminet / gfx / show / mpeg2decodeWOS.lha / mpeg2decode / src / amidisplay.c next >
C/C++ Source or Header  |  1999-02-25  |  57KB  |  2,069 lines
  1. /* amidisplay.c, Amiga interface                                              */
  2.  
  3. /* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */
  4.  
  5. /*
  6.  * Disclaimer of Warranty
  7.  *
  8.  * These software programs are available to the user without any license fee or
  9.  * royalty on an "as is" basis.  The MPEG Software Simulation Group disclaims
  10.  * any and all warranties, whether express, implied, or statuary, including any
  11.  * implied warranties or merchantability or of fitness for a particular
  12.  * purpose.  In no event shall the copyright-holder be liable for any
  13.  * incidental, punitive, or consequential damages of any kind whatsoever
  14.  * arising from the use of these programs.
  15.  *
  16.  * This disclaimer of warranty extends to the user of these programs and user's
  17.  * customers, employees, agents, transferees, successors, and assigns.
  18.  *
  19.  * The MPEG Software Simulation Group does not represent or warrant that the
  20.  * programs furnished hereunder are free of infringement of any third-party
  21.  * patents.
  22.  *
  23.  * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,
  24.  * are subject to royalty fees to patent holders.  Many of these patents are
  25.  * general enough such that they are unavoidable regardless of implementation
  26.  * design.
  27.  *
  28.  */
  29.  
  30. #ifdef DISPLAY
  31.  
  32.  /* the Xlib interface is closely modeled after
  33.   * mpeg_play 2.0 by the Berkeley Plateau Research Group
  34.   */
  35.  
  36. #include <stdio.h>
  37. #include <stdlib.h>
  38.  
  39. #include "config.h"
  40. #include "global.h"
  41.  
  42. #define CYBERGFXNAME     "cybergraphics.library"
  43. #define CYBERGFXVERSION  40L
  44.  
  45. #include<string.h>
  46. #include<dos.h>
  47. #include<exec/exec.h>
  48. #include<proto/exec.h>
  49. #include<dos/dos.h>
  50. #include<proto/dos.h>
  51. #include<graphics/gfx.h>
  52. #include<proto/graphics.h>
  53. #include<intuition/intuition.h>
  54. #include<proto/intuition.h>
  55. #include<proto/asl.h>
  56.  
  57. #include<cybergraphics/cybergraphics.h>
  58.  
  59. #ifdef STORM
  60. #include <clib/cybergraphics_protos.h>
  61. #include <powerpc/powerpc.h>
  62. #include <clib/powerpc_protos.h>
  63. int bus_MHz=60;
  64. int bus_clock=60000000;
  65. double tb_scale_lo;
  66. double tb_scale_hi;
  67. extern int wb;
  68. #else
  69. #include<proto/cybergraphics.h>
  70. #endif
  71.  
  72. struct RastPort *rp;
  73.  
  74. #ifdef STORM
  75. #include <clib/cybergraphics_protos.h>
  76. #include <clib/chunkyppc_protos.h>
  77. struct Library *ChunkyPPCBase;
  78. #else
  79. #include<proto/cybergraphics.h>
  80. #endif
  81.  
  82. #ifdef STORM
  83. struct TagItem helpbuf[3];
  84. int direct=1;
  85. UBYTE *address;
  86. int bpr;
  87. int opt=0;
  88. #endif
  89.  
  90. /* Amiga prototypes */
  91. struct Library *CyberGfxBase = NULL;
  92. struct Window *displayWindow = NULL;
  93. struct Screen *displayScreen = NULL;
  94. struct RastPort *tempRastPort = NULL;
  95. void *Ximage_Ptr, *Ximage_Ptr2;
  96.  
  97. void    c2p1x1_8_c5_ppc(void *chunky, void *bitplanes,
  98.             int chunkyx, int chunkyy,
  99.             int xoffset, int yoffset,
  100.             int bitplanesize);
  101. int __amiga_exit(void);
  102. void __amiga_checkdisplay(void);
  103. struct BitMap displayBitMap;
  104. int displayIsOpen = FALSE;
  105. int displayIsNative = TRUE;
  106.  
  107. /* private prototypes */
  108. static void Display_Image _ANSI_ARGS_((void *Ximage_Ptr, unsigned char *Dithered_Image));
  109. static void Dither_Frame _ANSI_ARGS_((unsigned char *src[]));
  110. static void Dither_Top_Field _ANSI_ARGS_((unsigned char *src[], unsigned char *dst));
  111. static void Dither_Bottom_Field _ANSI_ARGS_((unsigned char *src[], unsigned char *dst));
  112. static void Dither_Top_Field420 _ANSI_ARGS_((unsigned char *src[],
  113.                                       unsigned char *dst));
  114. static void Dither_Bottom_Field420 _ANSI_ARGS_((unsigned char *src[],
  115.                                       unsigned char *dst));
  116.  
  117.  
  118. /* local data */
  119. static unsigned char *Dithered_Image = NULL, *Dithered_Image2 = NULL, *Doubled_Image = NULL;
  120.  
  121. static unsigned char Y_Table[256+16];
  122. static unsigned char Cb_Table[128+16];
  123. static unsigned char Cr_Table[128+16];
  124.  
  125. static unsigned char Pixel[256];
  126.  
  127. /* connect to server, create and map window,
  128.  * allocate colors and (shared) memory
  129.  */
  130.  
  131. #ifndef STORM
  132. struct Library *TimerBase = NULL;
  133. struct timerequest *TimerIO = NULL;
  134. struct MsgPort *IDCMP = NULL;
  135. struct MsgPort *TimerMP = 0;
  136. #else
  137. void ppctimer(unsigned int[2]);
  138. #endif
  139.  
  140. void IO_StartupTimer (void)
  141. {
  142. // Ripped out of sourcecode of AmiHeretic...
  143. #ifdef STORM
  144.  struct TagItem ppcinfo[2]={GETINFO_BUSCLOCK,0,0,0};
  145.  GetInfo(ppcinfo);
  146.  bus_MHz=ppcinfo[0].ti_Data/(1000*1000);
  147.  bus_clock=ppcinfo[0].ti_Data;
  148.  tb_scale_lo = ((double)(bus_clock >> 2)) / 35.0;
  149.  tb_scale_hi = (4.294967296E9 / (double)(bus_clock >> 2)) * 35.0;
  150. #else
  151.     TimerMP = CreateMsgPort();
  152.     if (!TimerMP)
  153.         I_Error("I_InitTimer: Can't create timer message port");
  154.     TimerIO = (struct timerequest *)CreateExtIO(TimerMP, sizeof(struct timerequest));
  155.     if (!TimerIO)
  156.         I_Error("I_InitTimer: Can't create timer IO");
  157.  
  158.     if (OpenDevice((UBYTE *)TIMERNAME, UNIT_MICROHZ, (struct IORequest *)TimerIO, 0l) != 0)
  159.         I_Error("I_InitTimer: Can't open timer.device");
  160.  
  161.     TimerBase = (struct Library *)TimerIO->tr_node.io_Device;
  162. #endif
  163. }
  164.  
  165. void IO_ShutdownTimer(void)
  166. {
  167. // Ripped out of sourcecode of AmiHeretic...
  168. #ifndef STORM
  169.    if (TimerIO) {
  170.         CloseDevice((struct IORequest *)TimerIO);
  171.         DeleteExtIO((struct IORequest *)TimerIO);
  172.         TimerIO = 0;
  173.         TimerBase = 0;
  174.     }
  175.  
  176.     if (TimerMP) {
  177.         DeleteMsgPort(TimerMP);
  178.         TimerMP = 0;
  179.     }
  180. #endif
  181. }
  182.  
  183. long frames=0;
  184. long secs=0;
  185.  
  186. #ifdef STORM
  187. void video_do_fps()
  188. {
  189. // Ripped out of Source-Code of AmiHeretic, using 68k source
  190. // if STORM is not defined... small mod's, as mpeg2decode
  191. // uses intuition, and not rtgmaster which AmiHeretic is using...
  192.   int x;
  193.   static unsigned int start_time[2] = {0, 0};
  194.   unsigned int end_time[2];
  195.   char msg[4];
  196.  
  197.   ppctimer (end_time);
  198.   if (end_time[1] >= start_time[1])
  199.     x = (((end_time[1] - start_time[1]) << 2) / bus_MHz);
  200.   else
  201.     x = (((end_time[1] - start_time[1]) << 2) / bus_MHz + 1000000);
  202.   if (x != 0) {
  203.     x = (1000000 + (x >> 1)) / x;   /* round to nearest */
  204.     msg[0] = (x % 1000) / 100 + '0';
  205.     msg[1] = (x % 100) / 10 + '0';
  206.     msg[2] = (x % 10) + '0';
  207.     msg[3] = '\0';
  208.     Move(rp,Coded_Picture_Width*Double_Pixels-24,6);
  209.     Text(rp,msg,strlen(msg));
  210.   }
  211.   start_time[1] = end_time[1];
  212.   frames+=x;
  213.   secs+=1;
  214. }
  215. #else
  216. void video_do_fps()
  217. {
  218.     static struct timeval start;
  219.     static int init = 0;
  220.     struct timeval end, tmp;
  221.     char msg[4];
  222.     unsigned long x;
  223.  
  224.     if (init == 0) {
  225.         init = 1;
  226.         GetSysTime(&start);
  227.         return;
  228.     }
  229.  
  230.     GetSysTime(&end);
  231.     SubTime((struct timeval *)&end, (struct timeval *)&start);
  232.     x = (unsigned long)((float)frame++/(float)end.tv_secs);
  233.  
  234.     msg[0] = (x % 1000) / 100 + '0';
  235.     msg[1] = (x % 100) / 10 + '0';
  236.     msg[2] = (x % 10) + '0';
  237.     msg[3] = '\0';
  238.  
  239.     Move(rp,Coded_Picture_Width*Double_Pixels-24,6);
  240.     Text(rp,msg,strlen(msg));
  241.     frames+=x;
  242.     secs+=1;
  243. }
  244. #endif
  245.  
  246. #ifdef STORM
  247. struct TagItem asltags[]=
  248. {0,0
  249. };
  250. UBYTE *colarray1;
  251. unsigned long WBColorTable[3*256+2],ColorTable[3*256+2];
  252. UBYTE transtable[256];
  253. UBYTE *wbcolors;
  254. #include <graphics/rastport.h>
  255. int pen_obtained=0;
  256. void LoadRGBRtg(struct Window *MyWindow, ULONG Table[])
  257. {
  258.         // Slightly modified version of the rtgmaster function,
  259.         // taken out of rtgmaster source code...
  260.         struct TagItem EmptyTags[] =
  261.         {
  262.                 TAG_DONE,0
  263.         };
  264.         
  265.  
  266.         int i,r,g,b;
  267.         unsigned char *p;
  268.         struct ViewPort *VPort;
  269.         struct Window *Window;
  270.         struct ColorMap *ColorMap;
  271.  
  272.         ColorMap = MyWindow->WScreen->ViewPort.ColorMap;
  273.         VPort = &MyWindow->WScreen->ViewPort;
  274.  
  275.         if (!(pen_obtained))
  276.         {
  277.             WBColorTable[0] = 0x01000000;
  278.             WBColorTable[3*256+1] = 0;
  279.             GetRGB32(ColorMap,0,256,WBColorTable+1);
  280.             for (i=0;i<(3*256+2);i++)
  281.                 ColorTable[i] = WBColorTable[i];
  282.             for (i=0; i<256; i++)
  283.             {
  284.                     r = Table[3*i+1];
  285.                     g = Table[3*i+2];
  286.                     b = Table[3*i+3];
  287.                     r=r&0xFF000000;
  288.                     g=g&0xFF000000;
  289.                     b=b&0xFF000000;
  290.                     transtable[i] = ObtainBestPenA(ColorMap,r,g,b,EmptyTags);
  291.             }
  292.         }
  293.         for (i=0; i<256; i++)
  294.         {                
  295.                 ColorTable[3*transtable[i]+1] = Table[3*i+1];
  296.                 ColorTable[3*transtable[i]+2] = Table[3*i+2];
  297.                 ColorTable[3*transtable[i]+3] = Table[3*i+3];
  298.         }
  299.         LoadRGB32(VPort,ColorTable);
  300.         pen_obtained = TRUE;
  301. }
  302. #endif
  303.  
  304. #ifdef STORM
  305. void Initialize_Display_Process(char *name)
  306. #else
  307. void Initialize_Display_Process(name)
  308. char *name;
  309. #endif
  310. {
  311.     int crv, cbu, cgu, cgv;
  312.     int Y, Cb, Cr, R, G, B;
  313.     int i;
  314.     unsigned char *temp;
  315.     ULONG mycolors[770];
  316.  
  317.     displayIsOpen = TRUE;
  318.  
  319.     displayBitMap.Planes[0]=0;
  320.  
  321.     /* no mode selected, request one */
  322.  
  323.     if(Mode_ID == INVALID_ID)
  324.     {
  325.         struct ScreenModeRequester *sreq = NULL;
  326.      if (!wb)
  327.      {
  328. #ifdef STORM
  329.         if(sreq = (struct ScreenModeRequester *)AllocAslRequest(ASL_ScreenModeRequest,asltags))
  330. #else
  331.         if(sreq = (struct ScreenModeRequester *)AllocAslRequestTags(ASL_ScreenModeRequest,TAG_END))
  332. #endif
  333.         {
  334.             if(AslRequest(sreq,TAG_END))
  335.             {
  336.                 Mode_ID = sreq -> sm_DisplayID;
  337.                 printf("Next time, use option -m0x%lx\n",Mode_ID);
  338.             }
  339.             else
  340.                 Error("No valid screenmode selected\n");
  341.             FreeAslRequest(sreq);
  342.         }
  343.       }
  344.     }
  345.  
  346.     /* open cybergraphics.library */
  347.  
  348.     if(CyberGfxBase = OpenLibrary(CYBERGFXNAME,CYBERGFXVERSION))
  349.     {
  350.         if(IsCyberModeID(Mode_ID))
  351.             displayIsNative = FALSE;
  352.     }
  353. #ifdef STORM
  354.     if (!(ChunkyPPCBase = OpenLibrary("chunkyppc.library",0)))
  355.     {
  356.      direct=0;
  357.     }
  358. #endif
  359.     IO_StartupTimer();
  360.     /* setup automatically closing of the display */
  361.  
  362. #ifndef STORM
  363.     if(onbreak(&__amiga_exit)) Error("onbreak failed");
  364. #endif
  365.     if(atexit(&__amiga_checkdisplay)) Error("atexit failed");
  366.  
  367.     /* open screen */
  368.  
  369.     if(displayIsNative)
  370.     {
  371.  
  372.         if( !(temp = (unsigned char *)AllocRaster(Coded_Picture_Width*Double_Pixels,Coded_Picture_Height*Double_Pixels*8)) )
  373.             Error("AllocRaster failed");
  374.  
  375.         /* initialize bitmap */
  376.  
  377.         if (!wb)
  378.         {
  379.          InitBitMap( &displayBitMap, 8, Coded_Picture_Width*Double_Pixels, Coded_Picture_Height*Double_Pixels);
  380.  
  381.          /* attach image data to bitmap */
  382.  
  383.          for( i=0; i<8;i++ )
  384.              displayBitMap.Planes[i] = temp + i * RASSIZE (Coded_Picture_Width*Double_Pixels, Coded_Picture_Height*Double_Pixels);
  385.  
  386.          if(!(displayScreen = OpenScreenTags(NULL,
  387.                             SA_BitMap,&displayBitMap,
  388.                             SA_Width,Coded_Picture_Width*Double_Pixels,
  389.                             SA_Height,Coded_Picture_Height*Double_Pixels,
  390.                             SA_Title,"MPEG-2",
  391.                             SA_DisplayID,Mode_ID,
  392.                             SA_Depth,8,
  393.                             SA_ShowTitle,FALSE,
  394.                             TAG_END)))
  395.             Error("OpenScreenTags failed");
  396.         }
  397.     }
  398.     else
  399.     {
  400.         if (!wb)
  401.         {
  402.          if(!(displayScreen = OpenScreenTags(NULL,
  403.                             SA_Width,Coded_Picture_Width*Double_Pixels,
  404.                             SA_Height,Coded_Picture_Height*Double_Pixels,
  405.                             SA_Title,"MPEG-2",
  406.                             SA_DisplayID,Mode_ID,
  407.                             SA_Depth,8,
  408.                             SA_ShowTitle,FALSE,
  409.                             TAG_END)))
  410.             Error("OpenScreenTags failed");
  411.         }
  412.     }
  413.  
  414. #ifdef STORM
  415.     if ((Coded_Picture_Width*Double_Pixels)%64==0) opt=0;
  416.     else if ((Coded_Picture_Width*Double_Pixels)%8==0) opt=1;
  417.     else opt=2;
  418. #endif
  419.  
  420.     /* open window */
  421.  
  422. #ifdef STORM
  423.         if (direct)
  424.         {
  425.          helpbuf[0].ti_Tag=LBMI_BASEADDRESS;
  426.          helpbuf[0].ti_Data=(ULONG)&address;
  427.          helpbuf[1].ti_Tag=LBMI_BYTESPERROW;
  428.          helpbuf[1].ti_Data=(ULONG)&bpr;
  429.          helpbuf[2].ti_Tag=TAG_END;
  430.          helpbuf[2].ti_Data=0;
  431.          UnLockBitMap(LockBitMapTagList((displayScreen->RastPort).BitMap,helpbuf));
  432.         }
  433. #endif
  434.  
  435.     if (wb)
  436.     {
  437.      direct=0;
  438.      displayIsNative=0;
  439.      if(!(displayWindow = OpenWindowTags(NULL,
  440.                         WA_Title,"MPEG-2 Display",
  441.                         WA_InnerWidth,Coded_Picture_Width*Double_Pixels,
  442.                         WA_InnerHeight,Coded_Picture_Height*Double_Pixels,
  443.                         WA_GimmeZeroZero,TRUE,
  444.                         WA_DragBar,TRUE,
  445.                         WA_DepthGadget,TRUE,
  446.                         WA_IDCMP,IDCMP_RAWKEY,
  447.                         WA_Activate,TRUE,
  448.                         WA_NewLookMenus,TRUE,
  449.                         TAG_END)))
  450.         Error("OpenWindowTags failed");
  451.      wbcolors=(UBYTE *)AllocVec(256*4,MEMF_FAST|MEMF_CLEAR);
  452.      if (!wbcolors)
  453.      {
  454.       Error("Not enough memory");
  455.      }
  456.      colarray1=&(transtable[0]);
  457.      WBColorTable[0] = 0x01000000;
  458.      WBColorTable[3*256+1] = 0;
  459.      GetRGB32((displayWindow->WScreen->ViewPort).ColorMap,0,256,WBColorTable+1);
  460.     }
  461.     else
  462.     {
  463.  
  464.     if(!(displayWindow = OpenWindowTags(NULL,WA_CustomScreen,displayScreen,
  465.                         WA_Title,"MPEG-2 Display",
  466.                         WA_Width,Coded_Picture_Width*Double_Pixels,
  467.                         WA_Height,Coded_Picture_Height*Double_Pixels,
  468.                         WA_IDCMP,IDCMP_RAWKEY,
  469.                         WA_Backdrop,TRUE,
  470.                         WA_Borderless,TRUE,
  471.                         WA_RMBTrap,TRUE,
  472.                         WA_Activate,TRUE,
  473.                         WA_NewLookMenus,TRUE,
  474.                         WA_ScreenTitle,"MPEG-2",
  475.                         TAG_END)))
  476.         Error("OpenWindowTags failed");
  477.     }
  478.     //displayScreen = displayWindow -> WScreen;
  479.     /* matrix coefficients */
  480.     rp=displayWindow->RPort;
  481.     SetAPen(rp,1);
  482.     crv = Inverse_Table_6_9[matrix_coefficients][0];
  483.     cbu = Inverse_Table_6_9[matrix_coefficients][1];
  484.     cgu = Inverse_Table_6_9[matrix_coefficients][2];
  485.     cgv = Inverse_Table_6_9[matrix_coefficients][3];
  486.  
  487.     /* allocate colors */
  488.  
  489.     /* color allocation:
  490.     * i is the (internal) 8 bit color number, it consists of separate
  491.     * bit fields for Y, U and V: i = (yyyyuuvv), we don't use yyyy=0000
  492.     * and yyyy=1111, this leaves 32 colors for other applications
  493.     *
  494.     * the allocated colors correspond to the following Y, U and V values:
  495.     * Y:   24, 40, 56, 72, 88, 104, 120, 136, 152, 168, 184, 200, 216, 232
  496.     * U,V: -48, -16, 16, 48
  497.     *
  498.     * U and V values span only about half the color space; this gives
  499.     * usually much better quality, although highly saturated colors can
  500.     * not be displayed properly
  501.     *
  502.     * translation to R,G,B is implicitly done by the color look-up table
  503.     */
  504.  
  505.     for( i=0; i<256; i++) Pixel[i] = 0xff; /* clear to make sure that all colors are correctly freed */
  506.     mycolors[0]=0x01000000;
  507.     mycolors[3*256+1]=0;
  508.     mycolors[1]=255<<24;
  509.     mycolors[2]=255<<24;
  510.     mycolors[3]=255<<24;
  511.     for (i=1;i<16;i++)
  512.     {
  513.      mycolors[3*i+1]=0;
  514.      mycolors[3*i+2]=0;
  515.      mycolors[3*i+3]=0;
  516.     }
  517.     for( i=16; i<240; i++ )
  518.     {
  519.         /* color space conversion */
  520.  
  521.         Y  = 16*((i>>4)&15) + 8;
  522.         Cb = 32*((i>>2)&3)  - 48;
  523.         Cr = 32*(i&3)       - 48;
  524.  
  525.         Y = 76309 * (Y - 16); /* (255/219)*65536 */
  526.  
  527.         R = Clip[(Y + crv*Cr + 32768)>>16];
  528.         G = Clip[(Y - cgu*Cb - cgv*Cr + 32768)>>16];
  529.         B = Clip[(Y + cbu*Cb + 32786)>>16];
  530.         mycolors[3*i+1]=R<<24;
  531.         mycolors[3*i+2]=G<<24;
  532.         mycolors[3*i+3]=B<<24;
  533.         //if (!wb) SetRGB32(&displayScreen -> ViewPort,i,R<<24,G<<24,B<<24);
  534.         Pixel[i] = i;
  535.     }
  536.     if (!wb) LoadRGB32(&displayScreen->ViewPort,mycolors);
  537.     else LoadRGBRtg(displayWindow,mycolors);
  538.     /* allocate temporary rastport */
  539.  
  540.     if(!(tempRastPort = malloc(sizeof(struct RastPort))))
  541.         Error("malloc failed");
  542. #if 0
  543.     memcpy(tempRastPort,&displayScreen -> RastPort,sizeof(struct RastPort));
  544.     tempRastPort -> Layer = NULL;
  545.     tempRastPort -> BitMap = NULL;
  546.  
  547.     if(!(tempRastPort -> BitMap = AllocBitMap(((((Coded_Picture_Width*Double_Pixels)+15)>>4)<<1),1,((displayScreen -> RastPort).BitMap) -> Depth,NULL,NULL)))
  548.         Error("AllocBitMap failed");
  549. #endif
  550.     /* allocate buffers */
  551.  
  552.     if(!(Dithered_Image = (unsigned char *)malloc((Coded_Picture_Width)*4*(Coded_Picture_Height))))
  553.         Error("malloc failed");
  554.  
  555.     if(!progressive_sequence)
  556.     {
  557.         if(!(Dithered_Image2 = (unsigned char *)malloc((Coded_Picture_Width)*4*(Coded_Picture_Height))))
  558.             Error("malloc failed");
  559.     }
  560.  
  561.     if(!(Doubled_Image = (unsigned char *)malloc((Coded_Picture_Width*4*Double_Pixels)*(Coded_Picture_Height*Double_Pixels))))
  562.         Error("malloc failed");
  563. }
  564.  
  565. extern int fpscount;
  566.  
  567. int __amiga_exit(void)
  568. {
  569.     fprintf(stderr,"CTRL-C received\n");
  570.     return 1L;
  571. }
  572.  
  573. void __amiga_checkdisplay(void)
  574. {
  575.     if(displayIsOpen) Terminate_Display_Process();
  576. }
  577.  
  578. void Terminate_Display_Process()
  579. {
  580.     int i;
  581.  
  582.     if(Doubled_Image)
  583.     {
  584.         free(Doubled_Image);
  585.         Doubled_Image = NULL;
  586.     }
  587.     if(Dithered_Image2)
  588.     {
  589.         free(Dithered_Image2);
  590.         Dithered_Image2 = NULL;
  591.     }
  592.     if(Dithered_Image)
  593.     {
  594.         free(Dithered_Image);
  595.         Dithered_Image = NULL;
  596.     }
  597. #if 0
  598.     if(tempRastPort)
  599.     {
  600.         if(tempRastPort -> BitMap) FreeBitMap(tempRastPort -> BitMap);
  601.         free(tempRastPort);
  602.         tempRastPort = NULL;
  603.     }
  604. #endif
  605.  
  606.     if (!wb)
  607.     {
  608.      //for(i=0;i<256;i++) ReleasePen( (displayScreen -> ViewPort).ColorMap,Pixel[i]);
  609.     }
  610.     else
  611.     {
  612.      int i;
  613.      struct ColorMap *ColorMap=((displayWindow->WScreen)->ViewPort).ColorMap;
  614.      for (i=0; i<256; i++) ReleasePen(ColorMap,transtable[i]);
  615.      LoadRGB32(&(displayWindow->WScreen->ViewPort),WBColorTable);
  616.      FreeVec(wbcolors);
  617.     }
  618.  
  619.     if(displayWindow) CloseWindow(displayWindow);
  620.     if(displayScreen&&(!wb)) CloseScreen(displayScreen);
  621.  
  622.     if (!wb)
  623.     {
  624.      if(displayBitMap.Planes[0])
  625.      {
  626.          FreeRaster(displayBitMap.Planes[0],Coded_Picture_Width*Double_Pixels,Coded_Picture_Height*Double_Pixels*8);
  627.          displayBitMap.Planes[0]=NULL;
  628.      }
  629.     }
  630.     displayIsOpen = FALSE;
  631.  
  632.     /* close cybergraphics.library */
  633.  
  634.     if(CyberGfxBase)
  635.     {
  636.         CloseLibrary(CyberGfxBase);
  637.         CyberGfxBase = NULL;
  638.     }
  639. #ifdef STORM
  640.     if (ChunkyPPCBase)
  641.     {
  642.         CloseLibrary(ChunkyPPCBase);
  643.         ChunkyPPCBase=NULL;
  644.     }
  645. #endif
  646.     IO_ShutdownTimer();
  647. if (fpscount) printf("Average fps rate: %f\n",(float)(((float)frames)/((float)secs)));
  648. }
  649.  
  650. int Frame_Count = NULL;
  651. extern int fpscount;
  652. int truecolor=1;
  653.  
  654. void ARGBtoBGR(unsigned char *address,unsigned char *Dithered_Image,int w,int h,int bpr);
  655.  
  656.  
  657. UBYTE *taste=(UBYTE *)0xbfec01;
  658.  
  659. #ifdef STORM
  660. void ConvertFrame(UBYTE *,UBYTE *,unsigned long);
  661. static void Display_Image(void *Ximage_Ptr,unsigned char *Dithered_Image)
  662. #else
  663. static void Display_Image(Ximage_Ptr,Dithered_Image)
  664. void *Ximage_Ptr;
  665. unsigned char *Dithered_Image;
  666. #endif
  667. {
  668.     //static int count=0;
  669.     //printf("display: %ld\r",count++);
  670.     //fflush(stdout);
  671.  
  672.     /* scale picture to the double if -h is present */
  673.     if (*taste==0x39)
  674.     {
  675.      Terminate_Display_Process();
  676.      exit(0);
  677.     }
  678.  
  679.     if(Double_Pixels == 2)
  680.     {
  681.         int i,j;
  682.         unsigned char *dest_pointer = Doubled_Image;
  683.         unsigned char *source_pointer = Dithered_Image;
  684.         for(i=0;i<Coded_Picture_Height;i++)
  685.         {
  686.             for(j=0;j<Coded_Picture_Width;j++)
  687.             {
  688.                 *(dest_pointer++)=*source_pointer;
  689.                 *(dest_pointer++)=*(source_pointer++);
  690.             }
  691.             source_pointer-=Coded_Picture_Width;
  692.             for(j=0;j<Coded_Picture_Width;j++)
  693.             {
  694.                 *(dest_pointer)++=*source_pointer;
  695.                 *(dest_pointer)++=*(source_pointer++);
  696.             }
  697.         }
  698.  
  699.         Dithered_Image = Doubled_Image;
  700.     }
  701.     if (!wb)
  702.     {
  703. #ifdef STORM
  704.     if (direct)
  705.     {
  706.       if (!displayIsNative)
  707.       {
  708.        if (opt==0) ChunkyNoffFastest(address,Dithered_Image,(Coded_Picture_Width*Double_Pixels),(Coded_Picture_Height*Double_Pixels),bpr);
  709.        else if (opt==1) ChunkyNoffFast(address,Dithered_Image,(Coded_Picture_Width*Double_Pixels),(Coded_Picture_Height*Double_Pixels),bpr);
  710.        else ChunkyNoffNormal(address,Dithered_Image,(Coded_Picture_Width*Double_Pixels),(Coded_Picture_Height*Double_Pixels),bpr);
  711.       }
  712.       else c2p1x1_8_c5_ppc(Dithered_Image,displayBitMap.Planes[0],
  713.       Coded_Picture_Width*Double_Pixels,Coded_Picture_Height*Double_Pixels,
  714.       0, 0,
  715.       ((Coded_Picture_Width*Double_Pixels)*(Coded_Picture_Height*Double_Pixels))/8);
  716.     }
  717.     else
  718. #endif
  719.     {
  720.      if (!truecolor)
  721.      {
  722.      if(displayIsNative)
  723.          c2p1x1_8_c5_ppc(Dithered_Image,displayBitMap.Planes[0],
  724.                  Coded_Picture_Width*Double_Pixels,Coded_Picture_Height*Double_Pixels,
  725.                  0, 0,
  726.                  ((Coded_Picture_Width*Double_Pixels)*(Coded_Picture_Height*Double_Pixels))/8);
  727.      else
  728.          WritePixelArray8(&displayScreen -> RastPort,0,0,(Coded_Picture_Width*Double_Pixels)-1,(Coded_Picture_Height*Double_Pixels)-1,Dithered_Image,&displayScreen -> RastPort);
  729.      }
  730.      else
  731.      {
  732.       WritePixelArray(Dithered_Image,0,0,4*Coded_Picture_Width*Double_Pixels,rp,0,0,Coded_Picture_Width*Double_Pixels,Coded_Picture_Height*Double_Pixels,RECTFMT_ARGB);
  733.      }
  734.     }
  735.     }
  736.     else
  737.     {
  738.      if (!truecolor)
  739.      {
  740.       ConvertFrame(Dithered_Image,transtable,Coded_Picture_Width*Double_Pixels*Coded_Picture_Height*Double_Pixels);
  741.       WritePixelArray8(rp,0,0,(Coded_Picture_Width*Double_Pixels)-1,(Coded_Picture_Height*Double_Pixels)-1,Dithered_Image,rp);
  742.      }
  743.      else
  744.      {
  745.       WritePixelArray(Dithered_Image,0,0,4*Coded_Picture_Width*Double_Pixels,rp,0,0,Coded_Picture_Width*Double_Pixels,Coded_Picture_Height*Double_Pixels,RECTFMT_ARGB);
  746.      }
  747.     }
  748.     if (fpscount) video_do_fps();
  749. }
  750.  
  751. void Display_Second_Field()
  752. {
  753.     if(Frame_Count)
  754.     {
  755.         Frame_Count--;
  756.         return;
  757.     }
  758.     else
  759.         Frame_Count = Frame_Skip;
  760.  
  761.   Display_Image(Ximage_Ptr2,Dithered_Image2);
  762. }
  763.  
  764. /* 4x4 ordered dither
  765.  *
  766.  * threshold pattern:
  767.  *   0  8  2 10
  768.  *  12  4 14  6
  769.  *   3 11  1  9
  770.  *  15  7 13  5
  771.  */
  772.  
  773. void Initialize_Dither_Matrix()
  774. {
  775.   int i, v;
  776.  
  777.   for (i=-8; i<256+8; i++)
  778.   {
  779.     v = i>>4;
  780.     if (v<1)
  781.       v = 1;
  782.     else if (v>14)
  783.       v = 14;
  784.     Y_Table[i+8] = v<<4;
  785.   }
  786.  
  787.   for (i=0; i<128+16; i++)
  788.   {
  789.     v = (i-40)>>4;
  790.     if (v<0)
  791.       v = 0;
  792.     else if (v>3)
  793.       v = 3;
  794.     Cb_Table[i] = v<<2;
  795.     Cr_Table[i] = v;
  796.   }
  797. }
  798.  
  799. static void conv422to444(unsigned char *src,unsigned char *dst)
  800. {
  801.   int i, i2, w, j, im3, im2, im1, ip1, ip2, ip3;
  802.  
  803.   w = Coded_Picture_Width>>1;
  804.  
  805.   if (base.MPEG2_Flag)
  806.   {
  807.     for (j=0; j<Coded_Picture_Height; j++)
  808.     {
  809.       for (i=0; i<w; i++)
  810.       {
  811.         i2 = i<<1;
  812.         im2 = (i<2) ? 0 : i-2;
  813.         im1 = (i<1) ? 0 : i-1;
  814.         ip1 = (i<w-1) ? i+1 : w-1;
  815.         ip2 = (i<w-2) ? i+2 : w-1;
  816.         ip3 = (i<w-3) ? i+3 : w-1;
  817.  
  818.         /* FIR filter coefficients (*256): 21 0 -52 0 159 256 159 0 -52 0 21 */
  819.         /* even samples (0 0 256 0 0) */
  820.         dst[i2] = src[i];
  821.  
  822.         /* odd samples (21 -52 159 159 -52 21) */
  823.         dst[i2+1] = Clip[(int)(21*(src[im2]+src[ip3])
  824.                         -52*(src[im1]+src[ip2])
  825.                        +159*(src[i]+src[ip1])+128)>>8];
  826.       }
  827.       src+= w;
  828.       dst+= Coded_Picture_Width;
  829.     }
  830.   }
  831.   else
  832.   {
  833.     for (j=0; j<Coded_Picture_Height; j++)
  834.     {
  835.       for (i=0; i<w; i++)
  836.       {
  837.  
  838.         i2 = i<<1;
  839.         im3 = (i<3) ? 0 : i-3;
  840.         im2 = (i<2) ? 0 : i-2;
  841.         im1 = (i<1) ? 0 : i-1;
  842.         ip1 = (i<w-1) ? i+1 : w-1;
  843.         ip2 = (i<w-2) ? i+2 : w-1;
  844.         ip3 = (i<w-3) ? i+3 : w-1;
  845.  
  846.         /* FIR filter coefficients (*256): 5 -21 70 228 -37 11 */
  847.         dst[i2] =   Clip[(int)(  5*src[im3]
  848.                          -21*src[im2]
  849.                          +70*src[im1]
  850.                         +228*src[i]
  851.                          -37*src[ip1]
  852.                          +11*src[ip2]+128)>>8];
  853.  
  854.        dst[i2+1] = Clip[(int)(  5*src[ip3]
  855.                          -21*src[ip2]
  856.                          +70*src[ip1]
  857.                         +228*src[i]
  858.                          -37*src[im1]
  859.                          +11*src[im2]+128)>>8];
  860.       }
  861.       src+= w;
  862.       dst+= Coded_Picture_Width;
  863.     }
  864.   }
  865. }
  866.  
  867. /* vertical 1:2 interpolation filter */
  868. static void conv420to422(unsigned char *src,unsigned char *dst)
  869. {
  870.   int w, h, i, j, j2;
  871.   int jm6, jm5, jm4, jm3, jm2, jm1, jp1, jp2, jp3, jp4, jp5, jp6, jp7;
  872.  
  873.   w = Coded_Picture_Width>>1;
  874.   h = Coded_Picture_Height>>1;
  875.  
  876.   if (progressive_frame)
  877.   {
  878.     /* intra frame */
  879.     for (i=0; i<w; i++)
  880.     {
  881.       for (j=0; j<h; j++)
  882.       {
  883.         j2 = j<<1;
  884.         jm3 = (j<3) ? 0 : j-3;
  885.         jm2 = (j<2) ? 0 : j-2;
  886.         jm1 = (j<1) ? 0 : j-1;
  887.         jp1 = (j<h-1) ? j+1 : h-1;
  888.         jp2 = (j<h-2) ? j+2 : h-1;
  889.         jp3 = (j<h-3) ? j+3 : h-1;
  890.  
  891.         /* FIR filter coefficients (*256): 5 -21 70 228 -37 11 */
  892.         /* New FIR filter coefficients (*256): 3 -16 67 227 -32 7 */
  893.         dst[w*j2] =     Clip[(int)(  3*src[w*jm3]
  894.                              -16*src[w*jm2]
  895.                              +67*src[w*jm1]
  896.                             +227*src[w*j]
  897.                              -32*src[w*jp1]
  898.                              +7*src[w*jp2]+128)>>8];
  899.  
  900.         dst[w*(j2+1)] = Clip[(int)(  3*src[w*jp3]
  901.                              -16*src[w*jp2]
  902.                              +67*src[w*jp1]
  903.                             +227*src[w*j]
  904.                              -32*src[w*jm1]
  905.                              +7*src[w*jm2]+128)>>8];
  906.       }
  907.       src++;
  908.       dst++;
  909.     }
  910.   }
  911.   else
  912.   {
  913.     /* intra field */
  914.     for (i=0; i<w; i++)
  915.     {
  916.       for (j=0; j<h; j+=2)
  917.       {
  918.         j2 = j<<1;
  919.  
  920.         /* top field */
  921.         jm6 = (j<6) ? 0 : j-6;
  922.         jm4 = (j<4) ? 0 : j-4;
  923.         jm2 = (j<2) ? 0 : j-2;
  924.         jp2 = (j<h-2) ? j+2 : h-2;
  925.         jp4 = (j<h-4) ? j+4 : h-2;
  926.         jp6 = (j<h-6) ? j+6 : h-2;
  927.  
  928.         /* Polyphase FIR filter coefficients (*256): 2 -10 35 242 -18 5 */
  929.         /* New polyphase FIR filter coefficients (*256): 1 -7 30 248 -21 5 */
  930.         dst[w*j2] = Clip[(int)(  1*src[w*jm6]
  931.                          -7*src[w*jm4]
  932.                          +30*src[w*jm2]
  933.                         +248*src[w*j]
  934.                          -21*src[w*jp2]
  935.                           +5*src[w*jp4]+128)>>8];
  936.  
  937.         /* Polyphase FIR filter coefficients (*256): 11 -38 192 113 -30 8 */
  938.         /* New polyphase FIR filter coefficients (*256):7 -35 194 110 -24 4 */
  939.         dst[w*(j2+2)] = Clip[(int)( 7*src[w*jm4]
  940.                              -35*src[w*jm2]
  941.                             +194*src[w*j]
  942.                             +110*src[w*jp2]
  943.                              -24*src[w*jp4]
  944.                               +4*src[w*jp6]+128)>>8];
  945.  
  946.         /* bottom field */
  947.         jm5 = (j<5) ? 1 : j-5;
  948.         jm3 = (j<3) ? 1 : j-3;
  949.         jm1 = (j<1) ? 1 : j-1;
  950.         jp1 = (j<h-1) ? j+1 : h-1;
  951.         jp3 = (j<h-3) ? j+3 : h-1;
  952.         jp5 = (j<h-5) ? j+5 : h-1;
  953.         jp7 = (j<h-7) ? j+7 : h-1;
  954.  
  955.         /* Polyphase FIR filter coefficients (*256): 11 -38 192 113 -30 8 */
  956.         /* New polyphase FIR filter coefficients (*256):7 -35 194 110 -24 4 */
  957.         dst[w*(j2+1)] = Clip[(int)( 7*src[w*jp5]
  958.                              -35*src[w*jp3]
  959.                             +194*src[w*jp1]
  960.                             +110*src[w*jm1]
  961.                              -24*src[w*jm3]
  962.                               +4*src[w*jm5]+128)>>8];
  963.  
  964.         dst[w*(j2+3)] = Clip[(int)(  1*src[w*jp7]
  965.                              -7*src[w*jp5]
  966.                              +30*src[w*jp3]
  967.                             +248*src[w*jp1]
  968.                              -21*src[w*jm1]
  969.                               +5*src[w*jm3]+128)>>8];
  970.       }
  971.       src++;
  972.       dst++;
  973.     }
  974.   }
  975. }
  976.  
  977. /* Convert YUV->RGB *without* using interpolation */
  978. static void yuv_to_rgb_noint(unsigned char *src[],unsigned char *dst)
  979. {
  980.   int i,j;
  981.   int y,u,v;
  982.   int crv, cbu, cgu, cgv;
  983.   unsigned char *py,*pu,*pv;
  984.   unsigned char r, g, b, xdiffy, xdiffuv;
  985.  
  986.   py = src[0];
  987.   pu = src[1];
  988.   pv = src[2];
  989.  
  990.   /* matrix coefficients */
  991.   crv = Inverse_Table_6_9[matrix_coefficients][0];
  992.   cbu = Inverse_Table_6_9[matrix_coefficients][1];
  993.   cgu = Inverse_Table_6_9[matrix_coefficients][2];
  994.   cgv = Inverse_Table_6_9[matrix_coefficients][3];
  995.  
  996.   xdiffuv = xdiffy = Coded_Picture_Width-horizontal_size;
  997.   if (chroma_format!=CHROMA444)
  998.     xdiffuv/=2;
  999.  
  1000.   for (j=0; j<vertical_size; j++)
  1001.   {
  1002.     for (i=0; i<horizontal_size; i++)
  1003.     {
  1004.       if (i%2==0)
  1005.       {
  1006.         u = *pu++ - 128;
  1007.         v = *pv++ - 128;
  1008.       }
  1009.       else if (chroma_format==CHROMA444)
  1010.       {
  1011.         u = *pu++ - 128;
  1012.         v = *pv++ - 128;
  1013.       }
  1014.  
  1015.       y = 76309 * (*py++ - 16); /* (255/219)*65536 */
  1016.  
  1017.       r = Clip[(y + crv*v + 32768)>>16];
  1018.       g = Clip[(y - cgu*u - cgv*v + 32768)>>16];
  1019.       b = Clip[(y + cbu*u + 32786)>>16];
  1020.  
  1021.       *dst++ = r;
  1022.       *dst++ = g;
  1023.       *dst++ = b;
  1024.       *dst++ = b;
  1025.     }
  1026.  
  1027.     /* Increase pointers */
  1028.     py+=xdiffy;
  1029.     pu+=xdiffuv;
  1030.     pv+=xdiffuv;
  1031.  
  1032.     if (chroma_format==CHROMA420 && j%2==0)
  1033.     {
  1034.       pu -= Chroma_Width;
  1035.       pv -= Chroma_Width;
  1036.     }
  1037.   }
  1038. }
  1039.  
  1040. /* Convert YUV->RGB using interpolation */
  1041. static void yuv_to_rgb_int(unsigned char *src[],unsigned char *dst)
  1042. {
  1043.   int i, j;
  1044.   int y, u, v;
  1045.   int crv, cbu, cgu, cgv;
  1046.   int height, incr;
  1047.   unsigned char *py, *pu, *pv;
  1048.   unsigned char r, g, b;
  1049.   static unsigned char *u422, *v422, *u444, *v444;
  1050.  
  1051.   /* Init */
  1052.   height=vertical_size;
  1053.   incr=Coded_Picture_Width;
  1054.  
  1055.   /* Perform conversion */
  1056.  
  1057.   if (chroma_format==CHROMA444)
  1058.   {
  1059.     u444 = src[1];
  1060.     v444 = src[2];
  1061.   }
  1062.   else
  1063.   {
  1064.     if (!u444)
  1065.     {
  1066.       if (chroma_format==CHROMA420)
  1067.       {
  1068.         if (!(u422 = (unsigned char *)malloc((Coded_Picture_Width>>1)
  1069.                                              *Coded_Picture_Height)))
  1070.           Error("malloc failed");
  1071.         if (!(v422 = (unsigned char *)malloc((Coded_Picture_Width>>1)
  1072.                                              *Coded_Picture_Height)))
  1073.           Error("malloc failed");
  1074.       }
  1075.  
  1076.       if (!(u444 = (unsigned char *)malloc(Coded_Picture_Width
  1077.                                            *Coded_Picture_Height)))
  1078.         Error("malloc failed");
  1079.  
  1080.       if (!(v444 = (unsigned char *)malloc(Coded_Picture_Width
  1081.                                            *Coded_Picture_Height)))
  1082.         Error("malloc failed");
  1083.     }
  1084.  
  1085.     if (chroma_format==CHROMA420)
  1086.     {
  1087.       conv420to422(src[1],u422);
  1088.       conv420to422(src[2],v422);
  1089.       conv422to444(u422,u444);
  1090.       conv422to444(v422,v444);
  1091.     }
  1092.     else
  1093.     {
  1094.       conv422to444(src[1],u444);
  1095.       conv422to444(src[2],v444);
  1096.     }
  1097.   }
  1098.  
  1099.   /* matrix coefficients */
  1100.   crv = Inverse_Table_6_9[matrix_coefficients][0];
  1101.   cbu = Inverse_Table_6_9[matrix_coefficients][1];
  1102.   cgu = Inverse_Table_6_9[matrix_coefficients][2];
  1103.   cgv = Inverse_Table_6_9[matrix_coefficients][3];
  1104.  
  1105.   for (i=0; i<height; i++)
  1106.   {
  1107.     py = src[0] + incr*i;
  1108.     pu = u444 + incr*i;
  1109.     pv = v444 + incr*i;
  1110.  
  1111.     for (j=0; j<horizontal_size; j++)
  1112.     {
  1113.       u = *pu++ - 128;
  1114.       v = *pv++ - 128;
  1115.       y = 76309 * (*py++ - 16); /* (255/219)*65536 */
  1116.       r = Clip[(y + crv*v + 32768)>>16];
  1117.       g = Clip[(y - cgu*u - cgv*v + 32768)>>16];
  1118.       b = Clip[(y + cbu*u + 32786)>>16];
  1119.  
  1120.       *dst++ = r;
  1121.       *dst++ = g;
  1122.       *dst++ = b;
  1123.       *dst++ = b;
  1124.     }
  1125.   }
  1126. }
  1127.  
  1128. static void yuv_to_rgb(unsigned char *src[],unsigned char *dst)
  1129. {
  1130. #ifdef BLA
  1131.     yuv_to_rgb_int(src,dst);
  1132. #else
  1133.     yuv_to_rgb_noint(src,dst);
  1134. #endif
  1135. }
  1136.  
  1137. static void Dither_Frame_TrueCol(unsigned char *src[])
  1138. {
  1139.   if (!displayIsNative)
  1140.   {
  1141.     /* Perform YUV->RGB directly to destination */
  1142.     yuv_to_rgb(src, Dithered_Image);
  1143.   }
  1144.   else
  1145.   {
  1146.     /* YUV->RGB */
  1147.     //yuv_to_rgb(src, RGB_Image);
  1148.  
  1149.     /* RGB -> HAM6/8 conversion */
  1150.     //ham_c2p(RGB_Image, Dithered_Image, horizontal_size, vertical_size);
  1151.     // Fix this still...
  1152.   }
  1153. }
  1154.  
  1155. #ifdef STORM
  1156. void dither(unsigned char *src[])
  1157. #else
  1158. void dither(src)
  1159. unsigned char *src[];
  1160. #endif
  1161. {
  1162.   /* should this test only the display flag, not progressive_sequence ? --CF */
  1163.   /* CHANGE 95/05/13: progressive_sequence -> progressive_frame */
  1164.  
  1165.     if(Frame_Count)
  1166.     {
  1167.         Frame_Count--;
  1168.         return;
  1169.     }
  1170.     else
  1171.         Frame_Count = Frame_Skip;
  1172.  
  1173.   if (truecolor==0)
  1174.   {
  1175.   if( progressive_frame || Display_Progressive_Flag)
  1176.     Dither_Frame(src);
  1177.   else
  1178.   {
  1179.     if ((picture_structure==FRAME_PICTURE && top_field_first) || picture_structure==BOTTOM_FIELD)
  1180.     {
  1181.       /* top field first */
  1182.       if (chroma_format==CHROMA420 && hiQdither)
  1183.       {
  1184.         Dither_Top_Field420(src,Dithered_Image);
  1185.         Dither_Bottom_Field420(src,Dithered_Image2);
  1186.       }
  1187.       else
  1188.       {
  1189.         Dither_Top_Field(src,Dithered_Image);
  1190.         Dither_Bottom_Field(src,Dithered_Image2);
  1191.       }
  1192.     }
  1193.     else
  1194.     {
  1195.       /* bottom field first */
  1196.       if (chroma_format==CHROMA420 && hiQdither)
  1197.       {
  1198.         Dither_Bottom_Field420(src,Dithered_Image);
  1199.         Dither_Top_Field420(src,Dithered_Image2);
  1200.       }
  1201.       else
  1202.       {
  1203.         Dither_Bottom_Field(src,Dithered_Image);
  1204.         Dither_Top_Field(src,Dithered_Image2);
  1205.       }
  1206.     }
  1207.   }
  1208.   }
  1209.   else
  1210.   {
  1211.    Dither_Frame_TrueCol(src);
  1212.   }
  1213.  
  1214.   Display_Image(Ximage_Ptr,Dithered_Image);
  1215. }
  1216.  
  1217. #ifdef STORM
  1218. static void Dither_Frame(unsigned char *src[])
  1219. #else
  1220. static void Dither_Frame(src)
  1221. unsigned char *src[];
  1222. #endif
  1223. {
  1224.   int i,j;
  1225.   int y,u,v;
  1226.   unsigned char *py,*pu,*pv,*dst;
  1227.  
  1228.   py = src[0];
  1229.   pu = src[1];
  1230.   pv = src[2];
  1231.   dst = Dithered_Image;
  1232.  
  1233.   for (j=0; j<Coded_Picture_Height; j+=4)
  1234.   {
  1235.     /* line j + 0 */
  1236.     for (i=0; i<Coded_Picture_Width; i+=4)
  1237.     {
  1238.       y = *py++;
  1239.       u = *pu++ >> 1;
  1240.       v = *pv++ >> 1;
  1241.       *dst++ = Pixel[Y_Table[y]|Cb_Table[u]|Cr_Table[v]];
  1242.       y = *py++;
  1243.       if (chroma_format==CHROMA444)
  1244.       {
  1245.         u = *pu++ >> 1;
  1246.         v = *pv++ >> 1;
  1247.       }
  1248.       *dst++ = Pixel[Y_Table[y+8]|Cb_Table[u+8]|Cr_Table[v+8]];
  1249.       y = *py++;
  1250.       u = *pu++ >> 1;
  1251.       v = *pv++ >> 1;
  1252.       *dst++ = Pixel[Y_Table[y+2]|Cb_Table[u+2]|Cr_Table[v+2]];
  1253.       y = *py++;
  1254.       if (chroma_format==CHROMA444)
  1255.       {
  1256.         u = *pu++ >> 1;
  1257.         v = *pv++ >> 1;
  1258.       }
  1259.       *dst++ = Pixel[Y_Table[y+10]|Cb_Table[u+10]|Cr_Table[v+10]];
  1260.     }
  1261.  
  1262.     if (chroma_format==CHROMA420)
  1263.     {
  1264.       pu -= Chroma_Width;
  1265.       pv -= Chroma_Width;
  1266.     }
  1267.  
  1268.     /* line j + 1 */
  1269.     for (i=0; i<Coded_Picture_Width; i+=4)
  1270.     {
  1271.       y = *py++;
  1272.       u = *pu++ >> 1;
  1273.       v = *pv++ >> 1;
  1274.       *dst++ = Pixel[Y_Table[y+12]|Cb_Table[u+12]|Cr_Table[v+12]];
  1275.       y = *py++;
  1276.       if (chroma_format==CHROMA444)
  1277.       {
  1278.         u = *pu++ >> 1;
  1279.         v = *pv++ >> 1;
  1280.       }
  1281.       *dst++ = Pixel[Y_Table[y+4]|Cb_Table[u+4]|Cr_Table[v+4]];
  1282.       y = *py++;
  1283.       u = *pu++ >> 1;
  1284.       v = *pv++ >> 1;
  1285.       *dst++ = Pixel[Y_Table[y+14]|Cb_Table[u+14]|Cr_Table[v+14]];
  1286.       y = *py++;
  1287.       if (chroma_format==CHROMA444)
  1288.       {
  1289.         u = *pu++ >> 1;
  1290.         v = *pv++ >> 1;
  1291.       }
  1292.       *dst++ = Pixel[Y_Table[y+6]|Cb_Table[u+6]|Cr_Table[v+6]];
  1293.     }
  1294.  
  1295.     /* line j + 2 */
  1296.     for (i=0; i<Coded_Picture_Width; i+=4)
  1297.     {
  1298.       y = *py++;
  1299.       u = *pu++ >> 1;
  1300.       v = *pv++ >> 1;
  1301.       *dst++ = Pixel[Y_Table[y+3]|Cb_Table[u+3]|Cr_Table[v+3]];
  1302.       y = *py++;
  1303.       if (chroma_format==CHROMA444)
  1304.       {
  1305.         u = *pu++ >> 1;
  1306.         v = *pv++ >> 1;
  1307.       }
  1308.       *dst++ = Pixel[Y_Table[y+11]|Cb_Table[u+11]|Cr_Table[v+11]];
  1309.       y = *py++;
  1310.       u = *pu++ >> 1;
  1311.       v = *pv++ >> 1;
  1312.       *dst++ = Pixel[Y_Table[y+1]|Cb_Table[u+1]|Cr_Table[v+1]];
  1313.       y = *py++;
  1314.       if (chroma_format==CHROMA444)
  1315.       {
  1316.         u = *pu++ >> 1;
  1317.         v = *pv++ >> 1;
  1318.       }
  1319.       *dst++ = Pixel[Y_Table[y+9]|Cb_Table[u+9]|Cr_Table[v+9]];
  1320.     }
  1321.  
  1322.     if (chroma_format==CHROMA420)
  1323.     {
  1324.       pu -= Chroma_Width;
  1325.       pv -= Chroma_Width;
  1326.     }
  1327.  
  1328.     /* line j + 3 */
  1329.     for (i=0; i<Coded_Picture_Width; i+=4)
  1330.     {
  1331.       y = *py++;
  1332.       u = *pu++ >> 1;
  1333.       v = *pv++ >> 1;
  1334.       *dst++ = Pixel[Y_Table[y+15]|Cb_Table[u+15]|Cr_Table[v+15]];
  1335.       y = *py++;
  1336.       if (chroma_format==CHROMA444)
  1337.       {
  1338.         u = *pu++ >> 1;
  1339.         v = *pv++ >> 1;
  1340.       }
  1341.       *dst++ = Pixel[Y_Table[y+7]|Cb_Table[u+7]|Cr_Table[v+7]];
  1342.       y = *py++;
  1343.       u = *pu++ >> 1;
  1344.       v = *pv++ >> 1;
  1345.       *dst++ = Pixel[Y_Table[y+13]|Cb_Table[u+13]|Cr_Table[v+13]];
  1346.       y = *py++;
  1347.       if (chroma_format==CHROMA444)
  1348.       {
  1349.         u = *pu++ >> 1;
  1350.         v = *pv++ >> 1;
  1351.       }
  1352.       *dst++ = Pixel[Y_Table[y+5]|Cb_Table[u+5]|Cr_Table[v+5]];
  1353.     }
  1354.   }
  1355.  
  1356. }
  1357.  
  1358. #ifdef STORM
  1359. static void Dither_Top_Field(unsigned char *src[], unsigned char *dst)
  1360. #else
  1361. static void Dither_Top_Field(src,dst)
  1362. unsigned char *src[];
  1363. unsigned char *dst;
  1364. #endif
  1365. {
  1366.   int i,j;
  1367.   int y,Y2,u,v;
  1368.   unsigned char *py,*Y2_ptr,*pu,*pv,*dst2;
  1369.  
  1370.   py = src[0];
  1371.   Y2_ptr = src[0] + (Coded_Picture_Width<<1);
  1372.   pu = src[1];
  1373.   pv = src[2];
  1374.   dst2 = dst + Coded_Picture_Width;
  1375.  
  1376.   for (j=0; j<Coded_Picture_Height; j+=4)
  1377.   {
  1378.     /* line j + 0, j + 1 */
  1379.     for (i=0; i<Coded_Picture_Width; i+=4)
  1380.     {
  1381.       y = *py++;
  1382.       Y2 = *Y2_ptr++;
  1383.       u = *pu++ >> 1;
  1384.       v = *pv++ >> 1;
  1385.       *dst++  = Pixel[Y_Table[y]|Cb_Table[u]|Cr_Table[v]];
  1386.       *dst2++ = Pixel[Y_Table[((y+Y2)>>1)+12]|Cb_Table[u+12]|Cr_Table[v+12]];
  1387.  
  1388.       y = *py++;
  1389.       Y2 = *Y2_ptr++;
  1390.       if (chroma_format==CHROMA444)
  1391.       {
  1392.         u = *pu++ >> 1;
  1393.         v = *pv++ >> 1;
  1394.       }
  1395.       *dst++  = Pixel[Y_Table[y+8]|Cb_Table[u+8]|Cr_Table[v+8]];
  1396.       *dst2++ = Pixel[Y_Table[((y+Y2)>>1)+4]|Cb_Table[u+4]|Cr_Table[v+4]];
  1397.  
  1398.       y = *py++;
  1399.       Y2 = *Y2_ptr++;
  1400.       u = *pu++ >> 1;
  1401.       v = *pv++ >> 1;
  1402.       *dst++  = Pixel[Y_Table[y+2]|Cb_Table[u+2]|Cr_Table[v+2]];
  1403.       *dst2++ = Pixel[Y_Table[((y+Y2)>>1)+14]|Cb_Table[u+14]|Cr_Table[v+14]];
  1404.  
  1405.       y = *py++;
  1406.       Y2 = *Y2_ptr++;
  1407.       if (chroma_format==CHROMA444)
  1408.       {
  1409.         u = *pu++ >> 1;
  1410.         v = *pv++ >> 1;
  1411.       }
  1412.       *dst++  = Pixel[Y_Table[y+10]|Cb_Table[u+10]|Cr_Table[v+10]];
  1413.       *dst2++ = Pixel[Y_Table[((y+Y2)>>1)+6]|Cb_Table[u+6]|Cr_Table[v+6]];
  1414.     }
  1415.  
  1416.     py += Coded_Picture_Width;
  1417.  
  1418.     if (j!=(Coded_Picture_Height-4))
  1419.       Y2_ptr += Coded_Picture_Width;
  1420.     else
  1421.       Y2_ptr -= Coded_Picture_Width;
  1422.  
  1423.     dst += Coded_Picture_Width;
  1424.     dst2 += Coded_Picture_Width;
  1425.  
  1426.     if (chroma_format==CHROMA420)
  1427.     {
  1428.       pu -= Chroma_Width;
  1429.       pv -= Chroma_Width;
  1430.     }
  1431.     else
  1432.     {
  1433.       pu += Chroma_Width;
  1434.       pv += Chroma_Width;
  1435.     }
  1436.  
  1437.     /* line j + 2, j + 3 */
  1438.     for (i=0; i<Coded_Picture_Width; i+=4)
  1439.     {
  1440.       y = *py++;
  1441.       Y2 = *Y2_ptr++;
  1442.       u = *pu++ >> 1;
  1443.       v = *pv++ >> 1;
  1444.       *dst++  = Pixel[Y_Table[y+3]|Cb_Table[u+3]|Cr_Table[v+3]];
  1445.       *dst2++ = Pixel[Y_Table[((y+Y2)>>1)+15]|Cb_Table[u+15]|Cr_Table[v+15]];
  1446.  
  1447.       y = *py++;
  1448.       Y2 = *Y2_ptr++;
  1449.       if (chroma_format==CHROMA444)
  1450.       {
  1451.         u = *pu++ >> 1;
  1452.         v = *pv++ >> 1;
  1453.       }
  1454.       *dst++  = Pixel[Y_Table[y+11]|Cb_Table[u+11]|Cr_Table[v+11]];
  1455.       *dst2++ = Pixel[Y_Table[((y+Y2)>>1)+7]|Cb_Table[u+7]|Cr_Table[v+7]];
  1456.  
  1457.       y = *py++;
  1458.       Y2 = *Y2_ptr++;
  1459.       u = *pu++ >> 1;
  1460.       v = *pv++ >> 1;
  1461.       *dst++  = Pixel[Y_Table[y+1]|Cb_Table[u+1]|Cr_Table[v+1]];
  1462.       *dst2++ = Pixel[Y_Table[((y+Y2)>>1)+13]|Cb_Table[u+13]|Cr_Table[v+13]];
  1463.  
  1464.       y = *py++;
  1465.       Y2 = *Y2_ptr++;
  1466.       if (chroma_format==CHROMA444)
  1467.       {
  1468.         u = *pu++ >> 1;
  1469.         v = *pv++ >> 1;
  1470.       }
  1471.       *dst++  = Pixel[Y_Table[y+9]|Cb_Table[u+9]|Cr_Table[v+9]];
  1472.       *dst2++ = Pixel[Y_Table[((y+Y2)>>1)+5]|Cb_Table[u+5]|Cr_Table[v+5]];
  1473.     }
  1474.  
  1475.     py += Coded_Picture_Width;
  1476.     Y2_ptr += Coded_Picture_Width;
  1477.     dst += Coded_Picture_Width;
  1478.     dst2 += Coded_Picture_Width;
  1479.     pu += Chroma_Width;
  1480.     pv += Chroma_Width;
  1481.   }
  1482. }
  1483.  
  1484. #ifdef STORM
  1485. static void Dither_Bottom_Field(unsigned char *src[], unsigned char *dst)
  1486. #else
  1487. static void Dither_Bottom_Field(src,dst)
  1488. unsigned char *src[];
  1489. unsigned char *dst;
  1490. #endif
  1491. {
  1492.   int i,j;
  1493.   int y,Y2,u,v;
  1494.   unsigned char *py,*Y2_ptr,*pu,*pv,*dst2;
  1495.  
  1496.   py = src[0] + Coded_Picture_Width;
  1497.   Y2_ptr = py;
  1498.   pu = src[1] + Chroma_Width;
  1499.   pv = src[2] + Chroma_Width;
  1500.   dst2 = dst + Coded_Picture_Width;
  1501.  
  1502.   for (j=0; j<Coded_Picture_Height; j+=4)
  1503.   {
  1504.     /* line j + 0, j + 1 */
  1505.     for (i=0; i<Coded_Picture_Width; i+=4)
  1506.     {
  1507.       y = *py++;
  1508.       Y2 = *Y2_ptr++;
  1509.       u = *pu++ >> 1;
  1510.       v = *pv++ >> 1;
  1511.       *dst++  = Pixel[Y_Table[((y+Y2)>>1)]|Cb_Table[u]|Cr_Table[v]];
  1512.       *dst2++ = Pixel[Y_Table[Y2+12]|Cb_Table[u+12]|Cr_Table[v+12]];
  1513.  
  1514.       y = *py++;
  1515.       Y2 = *Y2_ptr++;
  1516.       if (chroma_format==CHROMA444)
  1517.       {
  1518.         u = *pu++ >> 1;
  1519.         v = *pv++ >> 1;
  1520.       }
  1521.       *dst++  = Pixel[Y_Table[((y+Y2)>>1)+8]|Cb_Table[u+8]|Cr_Table[v+8]];
  1522.       *dst2++ = Pixel[Y_Table[Y2+4]|Cb_Table[u+4]|Cr_Table[v+4]];
  1523.  
  1524.       y = *py++;
  1525.       Y2 = *Y2_ptr++;
  1526.       u = *pu++ >> 1;
  1527.       v = *pv++ >> 1;
  1528.       *dst++  = Pixel[Y_Table[((y+Y2)>>1)+2]|Cb_Table[u+2]|Cr_Table[v+2]];
  1529.       *dst2++ = Pixel[Y_Table[Y2+14]|Cb_Table[u+14]|Cr_Table[v+14]];
  1530.  
  1531.       y = *py++;
  1532.       Y2 = *Y2_ptr++;
  1533.       if (chroma_format==CHROMA444)
  1534.       {
  1535.         u = *pu++ >> 1;
  1536.         v = *pv++ >> 1;
  1537.       }
  1538.       *dst++  = Pixel[Y_Table[((y+Y2)>>1)+10]|Cb_Table[u+10]|Cr_Table[v+10]];
  1539.       *dst2++ = Pixel[Y_Table[Y2+6]|Cb_Table[u+6]|Cr_Table[v+6]];
  1540.     }
  1541.  
  1542.     if (j==0)
  1543.       py -= Coded_Picture_Width;
  1544.     else
  1545.       py += Coded_Picture_Width;
  1546.  
  1547.     Y2_ptr += Coded_Picture_Width;
  1548.     dst += Coded_Picture_Width;
  1549.     dst2 += Coded_Picture_Width;
  1550.  
  1551.     if (chroma_format==CHROMA420)
  1552.     {
  1553.       pu -= Chroma_Width;
  1554.       pv -= Chroma_Width;
  1555.     }
  1556.     else
  1557.     {
  1558.       pu += Chroma_Width;
  1559.       pv += Chroma_Width;
  1560.     }
  1561.  
  1562.     /* line j + 2. j + 3 */
  1563.     for (i=0; i<Coded_Picture_Width; i+=4)
  1564.     {
  1565.       y = *py++;
  1566.       Y2 = *Y2_ptr++;
  1567.       u = *pu++ >> 1;
  1568.       v = *pv++ >> 1;
  1569.       *dst++  = Pixel[Y_Table[((y+Y2)>>1)+3]|Cb_Table[u+3]|Cr_Table[v+3]];
  1570.       *dst2++ = Pixel[Y_Table[Y2+15]|Cb_Table[u+15]|Cr_Table[v+15]];
  1571.  
  1572.       y = *py++;
  1573.       Y2 = *Y2_ptr++;
  1574.       if (chroma_format==CHROMA444)
  1575.       {
  1576.         u = *pu++ >> 1;
  1577.         v = *pv++ >> 1;
  1578.       }
  1579.       *dst++  = Pixel[Y_Table[((y+Y2)>>1)+11]|Cb_Table[u+11]|Cr_Table[v+11]];
  1580.       *dst2++ = Pixel[Y_Table[Y2+7]|Cb_Table[u+7]|Cr_Table[v+7]];
  1581.  
  1582.       y = *py++;
  1583.       Y2 = *Y2_ptr++;
  1584.       u = *pu++ >> 1;
  1585.       v = *pv++ >> 1;
  1586.       *dst++  = Pixel[Y_Table[((y+Y2)>>1)+1]|Cb_Table[u+1]|Cr_Table[v+1]];
  1587.       *dst2++ = Pixel[Y_Table[Y2+13]|Cb_Table[u+13]|Cr_Table[v+13]];
  1588.  
  1589.       y = *py++;
  1590.       Y2 = *Y2_ptr++;
  1591.       if (chroma_format==CHROMA444)
  1592.       {
  1593.         u = *pu++ >> 1;
  1594.         v = *pv++ >> 1;
  1595.       }
  1596.       *dst++  = Pixel[Y_Table[((y+Y2)>>1)+9]|Cb_Table[u+9]|Cr_Table[v+9]];
  1597.       *dst2++ = Pixel[Y_Table[Y2+5]|Cb_Table[u+5]|Cr_Table[v+5]];
  1598.     }
  1599.  
  1600.     py += Coded_Picture_Width;
  1601.     Y2_ptr += Coded_Picture_Width;
  1602.     dst += Coded_Picture_Width;
  1603.     dst2 += Coded_Picture_Width;
  1604.     pu += Chroma_Width;
  1605.     pv += Chroma_Width;
  1606.   }
  1607. }
  1608.  
  1609. #ifndef STORM
  1610. static void Dither_Top_Field420(src,dst)
  1611. unsigned char *src[];
  1612. unsigned char *dst;
  1613. #else
  1614. static void Dither_Top_Field420(unsigned char *src[],unsigned char *dst)
  1615. #endif
  1616. {
  1617.   int i,j;
  1618.   int Y1,Cb1,Cr1,Y2,Cb2,Cr2;
  1619.   unsigned char *Y1_ptr,*Cb1_ptr,*Cr1_ptr,*Y2_ptr,*Cb2_ptr,*Cr2_ptr,*dst2;
  1620.  
  1621.   Y1_ptr = src[0];
  1622.   Cb1_ptr = src[1];
  1623.   Cr1_ptr = src[2];
  1624.  
  1625.   Y2_ptr = Y1_ptr + (Coded_Picture_Width<<1);
  1626.   Cb2_ptr = Cb1_ptr + (Chroma_Width<<1);
  1627.   Cr2_ptr = Cr1_ptr + (Chroma_Width<<1);
  1628.  
  1629.   dst2 = dst + Coded_Picture_Width;
  1630.  
  1631.   for (j=0; j<Coded_Picture_Height; j+=4)
  1632.   {
  1633.     /* line j + 0, j + 1 */
  1634.     for (i=0; i<Coded_Picture_Width; i+=4)
  1635.     {
  1636.       Y1 = *Y1_ptr++;
  1637.       Y2 = *Y2_ptr++;
  1638.       Cb1 = *Cb1_ptr++ >> 1;
  1639.       Cr1 = *Cr1_ptr++ >> 1;
  1640.       Cb2 = *Cb2_ptr++ >> 1;
  1641.       Cr2 = *Cr2_ptr++ >> 1;
  1642.       *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)]|Cb_Table[Cb1]|Cr_Table[Cr1]];
  1643.       *dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+12]|Cb_Table[((3*Cb1+Cb2)>>2)+12]
  1644.                                              |Cr_Table[((3*Cr1+Cr2)>>2)+12]];
  1645.  
  1646.       Y1 = *Y1_ptr++;
  1647.       Y2 = *Y2_ptr++;
  1648.       *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+8]|Cb_Table[Cb1+8]|Cr_Table[Cr1+8]];
  1649.       *dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+4]|Cb_Table[((3*Cb1+Cb2)>>2)+4]
  1650.                                             |Cr_Table[((3*Cr1+Cr2)>>2)+4]];
  1651.  
  1652.       Y1 = *Y1_ptr++;
  1653.       Y2 = *Y2_ptr++;
  1654.       Cb1 = *Cb1_ptr++ >> 1;
  1655.       Cr1 = *Cr1_ptr++ >> 1;
  1656.       Cb2 = *Cb2_ptr++ >> 1;
  1657.       Cr2 = *Cr2_ptr++ >> 1;
  1658.       *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+2]|Cb_Table[Cb1+2]|Cr_Table[Cr1+2]];
  1659.       *dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+14]|Cb_Table[((3*Cb1+Cb2)>>2)+14]
  1660.                                              |Cr_Table[((3*Cr1+Cr2)>>2)+14]];
  1661.  
  1662.       Y1 = *Y1_ptr++;
  1663.       Y2 = *Y2_ptr++;
  1664.       *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+10]|Cb_Table[Cb1+10]|Cr_Table[Cr1+10]];
  1665.       *dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+6]|Cb_Table[((3*Cb1+Cb2)>>2)+6]
  1666.                                             |Cr_Table[((3*Cr1+Cr2)>>2)+6]];
  1667.     }
  1668.  
  1669.     Y1_ptr += Coded_Picture_Width;
  1670.  
  1671.     if (j!=(Coded_Picture_Height-4))
  1672.       Y2_ptr += Coded_Picture_Width;
  1673.     else
  1674.       Y2_ptr -= Coded_Picture_Width;
  1675.  
  1676.     Cb1_ptr -= Chroma_Width;
  1677.     Cr1_ptr -= Chroma_Width;
  1678.     Cb2_ptr -= Chroma_Width;
  1679.     Cr2_ptr -= Chroma_Width;
  1680.  
  1681.     dst  += Coded_Picture_Width;
  1682.     dst2 += Coded_Picture_Width;
  1683.  
  1684.     /* line j + 2, j + 3 */
  1685.     for (i=0; i<Coded_Picture_Width; i+=4)
  1686.     {
  1687.       Y1 = *Y1_ptr++;
  1688.       Y2 = *Y2_ptr++;
  1689.       Cb1 = *Cb1_ptr++ >> 1;
  1690.       Cr1 = *Cr1_ptr++ >> 1;
  1691.       Cb2 = *Cb2_ptr++ >> 1;
  1692.       Cr2 = *Cr2_ptr++ >> 1;
  1693.       *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+3]|Cb_Table[((Cb1+Cb2)>>1)+3]
  1694.                                             |Cr_Table[((Cr1+Cr2)>>1)+3]];
  1695.       *dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+15]|Cb_Table[((Cb1+3*Cb2)>>2)+15]
  1696.                                              |Cr_Table[((Cr1+3*Cr2)>>2)+15]];
  1697.  
  1698.       Y1 = *Y1_ptr++;
  1699.       Y2 = *Y2_ptr++;
  1700.       *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+11]|Cb_Table[((Cb1+Cb2)>>1)+11]
  1701.                                              |Cr_Table[((Cr1+Cr2)>>1)+11]];
  1702.       *dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+7]|Cb_Table[((Cb1+3*Cb2)>>2)+7]
  1703.                                             |Cr_Table[((Cr1+3*Cr2)>>2)+7]];
  1704.  
  1705.       Y1 = *Y1_ptr++;
  1706.       Y2 = *Y2_ptr++;
  1707.       Cb1 = *Cb1_ptr++ >> 1;
  1708.       Cr1 = *Cr1_ptr++ >> 1;
  1709.       Cb2 = *Cb2_ptr++ >> 1;
  1710.       Cr2 = *Cr2_ptr++ >> 1;
  1711.       *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+1]|Cb_Table[((Cb1+Cb2)>>1)+1]
  1712.                                             |Cr_Table[((Cr1+Cr2)>>1)+1]];
  1713.       *dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+13]|Cb_Table[((Cb1+3*Cb2)>>2)+13]
  1714.                                              |Cr_Table[((Cr1+3*Cr2)>>2)+13]];
  1715.  
  1716.       Y1 = *Y1_ptr++;
  1717.       Y2 = *Y2_ptr++;
  1718.       *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+9]|Cb_Table[((Cb1+Cb2)>>1)+9]
  1719.                                             |Cr_Table[((Cr1+Cr2)>>1)+9]];
  1720.       *dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+5]|Cb_Table[((Cb1+3*Cb2)>>2)+5]
  1721.                                             |Cr_Table[((Cr1+3*Cr2)>>2)+5]];
  1722.     }
  1723.  
  1724.     Y1_ptr += Coded_Picture_Width;
  1725.     Y2_ptr += Coded_Picture_Width;
  1726.     Cb1_ptr += Chroma_Width;
  1727.     Cr1_ptr += Chroma_Width;
  1728.     if (j!=(Coded_Picture_Height-8))
  1729.     {
  1730.       Cb2_ptr += Chroma_Width;
  1731.       Cr2_ptr += Chroma_Width;
  1732.     }
  1733.     else
  1734.     {
  1735.       Cb2_ptr -= Chroma_Width;
  1736.       Cr2_ptr -= Chroma_Width;
  1737.     }
  1738.     dst += Coded_Picture_Width;
  1739.     dst2+= Coded_Picture_Width;
  1740.   }
  1741. }
  1742.  
  1743. #ifdef STORM
  1744. static void Dither_Bottom_Field420(unsigned char *src[],unsigned char *dst)
  1745. #else
  1746. static void Dither_Bottom_Field420(src,dst)
  1747. unsigned char *src[];
  1748. unsigned char *dst;
  1749. #endif
  1750. {
  1751.   int i,j;
  1752.   int Y1,Cb1,Cr1,Y2,Cb2,Cr2;
  1753.   unsigned char *Y1_ptr,*Cb1_ptr,*Cr1_ptr,*Y2_ptr,*Cb2_ptr,*Cr2_ptr,*dst2;
  1754.  
  1755.   Y2_ptr = Y1_ptr = src[0] + Coded_Picture_Width;
  1756.   Cb2_ptr = Cb1_ptr = src[1] + Chroma_Width;
  1757.   Cr2_ptr = Cr1_ptr = src[2] + Chroma_Width;
  1758.  
  1759.   dst2 = dst;
  1760.  
  1761.   for (j=0; j<Coded_Picture_Height; j+=4)
  1762.   {
  1763.     /* line j + 0, j + 1 */
  1764.     for (i=0; i<Coded_Picture_Width; i+=4)
  1765.     {
  1766.       Y1 = *Y1_ptr++;
  1767.       Y2 = *Y2_ptr++;
  1768.       Cb1 = *Cb1_ptr++ >> 1;
  1769.       Cr1 = *Cr1_ptr++ >> 1;
  1770.       Cb2 = *Cb2_ptr++ >> 1;
  1771.       Cr2 = *Cr2_ptr++ >> 1;
  1772.       *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+15]|Cb_Table[((3*Cb1+Cb2)>>2)+15]
  1773.                                              |Cr_Table[((3*Cr1+Cr2)>>2)+15]];
  1774.       *dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)]|Cb_Table[((Cb1+Cb2)>>1)]
  1775.                                           |Cr_Table[((Cr1+Cr2)>>1)]];
  1776.  
  1777.       Y1 = *Y1_ptr++;
  1778.       Y2 = *Y2_ptr++;
  1779.       *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+7]|Cb_Table[((3*Cb1+Cb2)>>2)+7]
  1780.                                             |Cr_Table[((3*Cr1+Cr2)>>2)+7]];
  1781.       *dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+8]|Cb_Table[((Cb1+Cb2)>>1)+8]
  1782.                                             |Cr_Table[((Cr1+Cr2)>>1)+8]];
  1783.  
  1784.       Y1 = *Y1_ptr++;
  1785.       Y2 = *Y2_ptr++;
  1786.       Cb1 = *Cb1_ptr++ >> 1;
  1787.       Cr1 = *Cr1_ptr++ >> 1;
  1788.       Cb2 = *Cb2_ptr++ >> 1;
  1789.       Cr2 = *Cr2_ptr++ >> 1;
  1790.       *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+13]|Cb_Table[((3*Cb1+Cb2)>>2)+13]
  1791.                                              |Cr_Table[((3*Cr1+Cr2)>>2)+13]];
  1792.       *dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+2]|Cb_Table[((Cb1+Cb2)>>1)+2]
  1793.                                             |Cr_Table[((Cr1+Cr2)>>1)+2]];
  1794.  
  1795.       Y1 = *Y1_ptr++;
  1796.       Y2 = *Y2_ptr++;
  1797.       *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+5]|Cb_Table[((3*Cb1+Cb2)>>2)+5]
  1798.                                             |Cr_Table[((3*Cr1+Cr2)>>2)+5]];
  1799.       *dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+10]|Cb_Table[((Cb1+Cb2)>>1)+10]
  1800.                                              |Cr_Table[((Cr1+Cr2)>>1)+10]];
  1801.     }
  1802.  
  1803.     if (j!=0)
  1804.       Y1_ptr += Coded_Picture_Width;
  1805.     else
  1806.       Y1_ptr -= Coded_Picture_Width;
  1807.  
  1808.     Y2_ptr += Coded_Picture_Width;
  1809.  
  1810.     Cb1_ptr -= Chroma_Width;
  1811.     Cr1_ptr -= Chroma_Width;
  1812.     Cb2_ptr -= Chroma_Width;
  1813.     Cr2_ptr -= Chroma_Width;
  1814.  
  1815.     if (j!=0)
  1816.       dst  += Coded_Picture_Width;
  1817.  
  1818.     dst2 += Coded_Picture_Width;
  1819.  
  1820.     /* line j + 2, j + 3 */
  1821.     for (i=0; i<Coded_Picture_Width; i+=4)
  1822.     {
  1823.       Y1 = *Y1_ptr++;
  1824.       Y2 = *Y2_ptr++;
  1825.       Cb1 = *Cb1_ptr++ >> 1;
  1826.       Cr1 = *Cr1_ptr++ >> 1;
  1827.       Cb2 = *Cb2_ptr++ >> 1;
  1828.       Cr2 = *Cr2_ptr++ >> 1;
  1829.       *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+12]|Cb_Table[((Cb1+3*Cb2)>>2)+12]
  1830.                                              |Cr_Table[((Cr1+3*Cr2)>>2)+12]];
  1831.       *dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+3]|Cb_Table[Cb2+3]
  1832.                                             |Cr_Table[Cr2+3]];
  1833.  
  1834.       Y1 = *Y1_ptr++;
  1835.       Y2 = *Y2_ptr++;
  1836.       *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+4]|Cb_Table[((Cb1+3*Cb2)>>2)+4]
  1837.                                             |Cr_Table[((Cr1+3*Cr2)>>2)+4]];
  1838.       *dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+11]|Cb_Table[Cb2+11]
  1839.                                              |Cr_Table[Cr2+11]];
  1840.  
  1841.       Y1 = *Y1_ptr++;
  1842.       Y2 = *Y2_ptr++;
  1843.       Cb1 = *Cb1_ptr++ >> 1;
  1844.       Cr1 = *Cr1_ptr++ >> 1;
  1845.       Cb2 = *Cb2_ptr++ >> 1;
  1846.       Cr2 = *Cr2_ptr++ >> 1;
  1847.       *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+14]|Cb_Table[((Cb1+3*Cb2)>>2)+14]
  1848.                                              |Cr_Table[((Cr1+3*Cr2)>>2)+14]];
  1849.       *dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+1]|Cb_Table[Cb2+1]
  1850.                                             |Cr_Table[Cr2+1]];
  1851.  
  1852.       Y1 = *Y1_ptr++;
  1853.       Y2 = *Y2_ptr++;
  1854.       *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+6]|Cb_Table[((Cb1+3*Cb2)>>2)+6]
  1855.                                             |Cr_Table[((Cr1+3*Cr2)>>2)+6]];
  1856.       *dst2++ = Pixel[Y_Table[((Y1+3*Y2)>>2)+9]|Cb_Table[Cb2+9]
  1857.                                             |Cr_Table[Cr2+9]];
  1858.     }
  1859.  
  1860.     Y1_ptr += Coded_Picture_Width;
  1861.     Y2_ptr += Coded_Picture_Width;
  1862.  
  1863.     if (j!=0)
  1864.     {
  1865.       Cb1_ptr += Chroma_Width;
  1866.       Cr1_ptr += Chroma_Width;
  1867.     }
  1868.     else
  1869.     {
  1870.       Cb1_ptr -= Chroma_Width;
  1871.       Cr1_ptr -= Chroma_Width;
  1872.     }
  1873.  
  1874.     Cb2_ptr += Chroma_Width;
  1875.     Cr2_ptr += Chroma_Width;
  1876.  
  1877.     dst += Coded_Picture_Width;
  1878.     dst2+= Coded_Picture_Width;
  1879.   }
  1880.  
  1881.   Y2_ptr -= (Coded_Picture_Width<<1);
  1882.   Cb2_ptr -= (Chroma_Width<<1);
  1883.   Cr2_ptr -= (Chroma_Width<<1);
  1884.  
  1885.   /* dither last line */
  1886.   for (i=0; i<Coded_Picture_Width; i+=4)
  1887.   {
  1888.     Y1 = *Y1_ptr++;
  1889.     Y2 = *Y2_ptr++;
  1890.     Cb1 = *Cb1_ptr++ >> 1;
  1891.     Cr1 = *Cr1_ptr++ >> 1;
  1892.     Cb2 = *Cb2_ptr++ >> 1;
  1893.     Cr2 = *Cr2_ptr++ >> 1;
  1894.     *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+15]|Cb_Table[((3*Cb1+Cb2)>>2)+15]
  1895.                                            |Cr_Table[((3*Cr1+Cr2)>>2)+15]];
  1896.  
  1897.     Y1 = *Y1_ptr++;
  1898.     Y2 = *Y2_ptr++;
  1899.     *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+7]|Cb_Table[((3*Cb1+Cb2)>>2)+7]
  1900.                                           |Cr_Table[((3*Cr1+Cr2)>>2)+7]];
  1901.  
  1902.     Y1 = *Y1_ptr++;
  1903.     Y2 = *Y2_ptr++;
  1904.     Cb1 = *Cb1_ptr++ >> 1;
  1905.     Cr1 = *Cr1_ptr++ >> 1;
  1906.     Cb2 = *Cb2_ptr++ >> 1;
  1907.     Cr2 = *Cr2_ptr++ >> 1;
  1908.     *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+13]|Cb_Table[((3*Cb1+Cb2)>>2)+13]
  1909.                                            |Cr_Table[((3*Cr1+Cr2)>>2)+13]];
  1910.  
  1911.     Y1 = *Y1_ptr++;
  1912.     Y2 = *Y2_ptr++;
  1913.     *dst++  = Pixel[Y_Table[((3*Y1+Y2)>>2)+5]|Cb_Table[((3*Cb1+Cb2)>>2)+5]
  1914.                                           |Cr_Table[((3*Cr1+Cr2)>>2)+5]];
  1915.     }
  1916.  
  1917. }
  1918.  
  1919. #define twomerges1(a, b, c, d, shift, mask) \
  1920.     { \
  1921.     temp1 = b; \
  1922.     temp2 = d; \
  1923.     temp1 >>= shift; \
  1924.     temp2 >>= shift; \
  1925.     temp1 ^= a; \
  1926.     temp2 ^= c; \
  1927.     temp1 &= mask; \
  1928.     temp2 &= mask; \
  1929.     a ^= temp1; \
  1930.     c ^= temp2; \
  1931.     temp1 <<= shift; \
  1932.     temp2 <<= shift; \
  1933.     b ^= temp1; \
  1934.     d ^= temp2; \
  1935.     }
  1936.  
  1937. #define twomerges2(a, b, c, d, shift, mask) \
  1938.     { \
  1939.     temp1 = (a ^ (b >> shift)) & mask; \
  1940.     temp2 = (c ^ (d >> shift)) & mask; \
  1941.     a ^= temp1; \
  1942.     c ^= temp2; \
  1943.     b ^= temp1 << shift; \
  1944.     d ^= temp2 << shift; \
  1945.     }
  1946.  
  1947. void    c2p1x1_8_c5_ppc(void *chunky, void *bitplanes,
  1948.             int chunkyx, int chunkyy,
  1949.             int xoffset, int yoffset,
  1950.             int bitplanesize)
  1951. {
  1952. typedef unsigned long ULONG;
  1953.  
  1954.     ULONG   *c;
  1955.     ULONG   temp1, temp2;
  1956.     ULONG   *p0, *p1, *p2, *p3, *p4, *p5, *p6, *p7;
  1957.     ULONG   d0, d1, d2, d3, d4, d5, d6, d7;
  1958.     ULONG   t0, t1, t2, t3, t4, t5, t6, t7;
  1959.     int i;
  1960.  
  1961.     c = (ULONG *) chunky;
  1962.     p0 = (ULONG *) (&(((char *) bitplanes)[yoffset * chunkyx >> 3]));
  1963.     p1 = (ULONG *) (&(((char *) p0)[bitplanesize]));
  1964.     p2 = (ULONG *) (&(((char *) p1)[bitplanesize]));
  1965.     p3 = (ULONG *) (&(((char *) p2)[bitplanesize]));
  1966.     p4 = (ULONG *) (&(((char *) p3)[bitplanesize]));
  1967.     p5 = (ULONG *) (&(((char *) p4)[bitplanesize]));
  1968.     p6 = (ULONG *) (&(((char *) p5)[bitplanesize]));
  1969.     p7 = (ULONG *) (&(((char *) p6)[bitplanesize]));
  1970.  
  1971.     i = chunkyx * chunkyy / (sizeof (ULONG) * 8);
  1972.  
  1973.     d0 = *c++;
  1974.     d1 = *c++;
  1975.     d2 = *c++;
  1976.     d3 = *c++;
  1977.     d4 = *c++;
  1978.     d5 = *c++;
  1979.     d6 = *c++;
  1980.     d7 = *c++;
  1981.  
  1982.     twomerges1(d0, d4, d1, d5, 16, 0x0000ffff);
  1983.     twomerges1(d2, d6, d3, d7, 16, 0x0000ffff);
  1984.  
  1985.     twomerges1(d0, d2, d1, d3, 8, 0x00ff00ff);
  1986.     twomerges1(d4, d6, d5, d7, 8, 0x00ff00ff);
  1987.  
  1988.     twomerges1(d0, d1, d2, d3, 4, 0x0f0f0f0f);
  1989.     twomerges1(d4, d5, d6, d7, 4, 0x0f0f0f0f);
  1990.  
  1991.     twomerges1(d0, d4, d1, d5, 2, 0x33333333);
  1992.     twomerges1(d2, d6, d3, d7, 2, 0x33333333);
  1993.  
  1994.     twomerges1(d0, d2, d1, d3, 1, 0x55555555);
  1995.     twomerges1(d4, d6, d5, d7, 1, 0x55555555);
  1996.  
  1997.     t0 = d7;
  1998.     t1 = d5;
  1999.     t2 = d3;
  2000.     t3 = d1;
  2001.     t4 = d6;
  2002.     t5 = d4;
  2003.     t6 = d2;
  2004.     t7 = d0;
  2005.  
  2006.     while (--i)
  2007.     {
  2008.         d0 = *c++;
  2009.         d1 = *c++;
  2010.         d2 = *c++;
  2011.         d3 = *c++;
  2012.         d4 = *c++;
  2013.         d5 = *c++;
  2014.         d6 = *c++;
  2015.         d7 = *c++;
  2016.  
  2017.         *p0++ = t0;
  2018.  
  2019.         twomerges1(d0, d4, d1, d5, 16, 0x0000ffff);
  2020.         twomerges1(d2, d6, d3, d7, 16, 0x0000ffff);
  2021.  
  2022.         *p1++ = t1;
  2023.  
  2024.         twomerges1(d0, d2, d1, d3, 8, 0x00ff00ff);
  2025.         twomerges1(d4, d6, d5, d7, 8, 0x00ff00ff);
  2026.  
  2027.         *p2++ = t2;
  2028.  
  2029.         twomerges1(d0, d1, d2, d3, 4, 0x0f0f0f0f);
  2030.         twomerges1(d4, d5, d6, d7, 4, 0x0f0f0f0f);
  2031.  
  2032.         *p3++ = t3;
  2033.  
  2034.         twomerges1(d0, d4, d1, d5, 2, 0x33333333);
  2035.         twomerges1(d2, d6, d3, d7, 2, 0x33333333);
  2036.  
  2037.         *p4++ = t4;
  2038.  
  2039.         twomerges1(d0, d2, d1, d3, 1, 0x55555555);
  2040.         twomerges1(d4, d6, d5, d7, 1, 0x55555555);
  2041.  
  2042.         *p5++ = t5;
  2043.         *p6++ = t6;
  2044.         *p7++ = t7;
  2045.  
  2046.         t0 = d7;
  2047.         t1 = d5;
  2048.         t2 = d3;
  2049.         t3 = d1;
  2050.         t4 = d6;
  2051.         t5 = d4;
  2052.         t6 = d2;
  2053.         t7 = d0;
  2054.  
  2055.     }
  2056.  
  2057.     *p0++ = t0;
  2058.     *p1++ = t1;
  2059.     *p2++ = t2;
  2060.     *p3++ = t3;
  2061.     *p4++ = t4;
  2062.     *p5++ = t5;
  2063.     *p6++ = t6;
  2064.     *p7++ = t7;
  2065.  
  2066. }
  2067.  
  2068. #endif
  2069.